package demo1;
//实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值？
//可以存放任何类型的数据，但是是我指定的任何类型的数据
//class MyArray{
//    Object[] objects = new Object[10];
//    public Object getObject(int pos){
//        return objects[pos];
//    }
//    public void setObjects(int pos,Object val){
//        objects[pos] = val;
//    }
//}

import java.lang.reflect.Array;
import java.util.Arrays;

/*
*@param <T>，T是一个占位符，表示当前类是一个泛型类
 */
class MyArray<T>{
//    Object[] objects = new Object[10];//这样写也对
//    public T[] Objects = new T[10];//这样写也行
    public T[] objects = (T[]) new Object[10];//这样写不太好

    public MyArray() {

    }
    public MyArray(Class<T> clazz,int capacity){
        objects = (T[]) Array.newInstance(clazz,capacity);//表明当前的类型变成了T类型.
    }//这种写法一定是要实例化一个泛型数组才可以，在实际的写法中还是按照MyArray1的写法来写，以后都像那样写

    public T getObject(int pos){
        return objects[pos];
    }
    public void setObjects(int pos,T val){
        objects[pos] = val;
    }
    public T[] getArray(){
        return objects;
    }
}

class MyArray1<T>{//以后都这样写
        Object[] objects = new Object[10];//这样写也对
////    public T[] Objects = new T[10];//这样写也行
//    public T[] objects = (T[]) new Object[10];//这样写不太好
    public T getObject(int pos){
        return (T)objects[pos];//在里面进行强制类型转换，因为这个时候已经建立了对象，知道该对象的类型
    }
    public void setObjects(int pos,T val){
        objects[pos] = val;
    }
    public Object[] getArray(){
        return objects;
    }
}


public class Test1 {
    public static void main4(String[] args) {
        MyArray1<Integer> myArray1 = new MyArray1<>();
        myArray1.setObjects(0,10);
        myArray1.setObjects(1,20);
        myArray1.setObjects(2,30);
        Object[] arr1 = myArray1.getArray();
        System.out.println(Arrays.toString(arr1));
    }
    public static void main(String[] args) {
        MyArray<Integer> myArray1 = new MyArray<>(Integer.class,10);
        Integer[] integers = myArray1.getArray();//此时运行就会报错，因为不允许将Object类型数据转换为Integer类型数据，因为Object类型里面可能存放多种类型的数据
        //所以public T[] objects = (T[]) new Object[10];这种写法不安全，不好，故修改为MyArray1<T>的形式
        //如果非要像public T[] objects = (T[]) new Object[10];这样写，则需要写一个构造方法public MyArray(Class<T> clazz,int capacity)

    }
    public static void main2(String[] args) {
        MyArray<Integer> myArray1 = new MyArray<Integer>();//传入了类型Integer
        myArray1.setObjects(0,10);
        myArray1.setObjects(1,48);
        int val1 = myArray1.getObject(1);
        System.out.println(val1);
        MyArray<String> myArray2 = new MyArray<>();//后面的String可以省略不写
        myArray2.setObjects(0,"hello");
        myArray2.setObjects(1,"bit");
        String val2 = myArray2.getObject(1);
        System.out.println(val2);
    }
    public static void main1(String[] args) {
        //这种情况是什么数据类型都可以放，叫做裸类型
        MyArray myArray = new MyArray();
        myArray.setObjects(0,"1234");
        myArray.setObjects(1,10);
        int val1 = (int)myArray.getObject(1);//因为getObject方法返回的是一个Object类型的数据，
        // 所以需要进行强制类型转换，故引入泛型，也就是上面新定义的MyArray<T>类，对应于上面的main函数
        System.out.println(val1);
    }

}
